/*
 * Copyright (C), 2002-2016, 苏宁易购电子商务有限公司
 * FileName: ModelProbDaoServiceImpl.java
 * Author:   13075787
 * Date:     2016年7月4日 上午8:38:13
 * Description: //模块目的、功能描述      
 * History: //修改记录
 * <author>      <time>      <version>    <desc>
 * 修改人姓名             修改时间            版本号                  描述
 */
package com.suning.sawp.service.impl.model;

import java.util.Date;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import javax.annotation.Resource;

import org.apache.commons.collections.CollectionUtils;
import org.apache.commons.lang3.StringUtils;
import org.springframework.stereotype.Service;

import com.suning.framework.dal.client.DalClient;
import com.suning.sawp.intf.model.ModelConstant;
import com.suning.sawp.intf.model.ModelProbOprReqBean;
import com.suning.sawp.intf.model.ModelProbVo;
import com.suning.sawp.service.util.BeanUtil;

/**
 * 样机管理<br>
 * 样机异常处理和审核
 *
 * @author 13075787
 * @see [相关类/方法]（可选）
 * @since [产品/模块版本] （可选）
 */
@Service("modelProbDaoService")
public class ModelProbDaoServiceImpl {

    private static final int NUM_ZERO = 0;
    /**
     * 最大每页分页数
     */
    private static final int MAX_SIZE = 20;

    /**
     * sqlMap中属性值
     */
    private static final String SQL_COUNT_KEY = "NUM";

    @Resource
    DalClient dalClient;

    /**
     * 功能描述: <br>
     * 查询该员工下是否存在未审核的数据
     *
     * @param auditStaffId-审核人
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public boolean queryProbAuditFlag(String auditStaffId) {
        boolean result = false;
        if (StringUtils.isNotBlank(auditStaffId)) {
            Map<String, Object> paramMap = new HashMap<String, Object>();
            // 审核中的数据
            paramMap.put("status", ModelConstant.PROBLEM_OPR_STATUS_DONE);
            // 审核人
            paramMap.put("auditStaff", auditStaffId);
            Map<String, Object> retMap = dalClient.queryForMap("MODEL_PROBLEM_LIST.SELECT_PROB_AUDIT_OR_HANDLING_FLAG",
                    paramMap);
            // 结果判空
            if (null != retMap && null != retMap.get(SQL_COUNT_KEY)) {
                result = Long.valueOf((Long) retMap.get(SQL_COUNT_KEY)) > NUM_ZERO ? true : false;
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 查询该员工下是否存在未处理的数据
     *
     * @param checkStaffId-盘点人员
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public boolean queryProbHandlingFlag(String checkStaffId) {
        boolean result = false;
        if (StringUtils.isNotBlank(checkStaffId)) {
            Map<String, Object> paramMap = new HashMap<String, Object>();
            // 处理中的数据
            paramMap.put("status", ModelConstant.PROBLEM_OPR_STATUS_ING);
            // 盘点人(处理人)
            paramMap.put("checkStaff", checkStaffId);
            Map<String, Object> retMap = dalClient.queryForMap("MODEL_PROBLEM_LIST.SELECT_PROB_AUDIT_OR_HANDLING_FLAG",
                    paramMap);
            // 结果判空
            if (null != retMap && null != retMap.get(SQL_COUNT_KEY)) {
                result = Long.valueOf((Long) retMap.get(SQL_COUNT_KEY)) > NUM_ZERO ? true : false;
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 查询样机异常未处理或未审核数据
     */
    private List<ModelProbVo> queryModelProbVoList(String staffId, Integer status, Integer index, Integer size) {
        List<ModelProbVo> result = null;
        if (StringUtils.isNotBlank(staffId) && null != status) {
            boolean queryFlag = true;
            Integer locIndex = null == index || index.intValue() < NUM_ZERO ? NUM_ZERO : index;
            Integer locSize = null == size || size.intValue() > MAX_SIZE ? MAX_SIZE : size;
            Map<String, Object> paramMap = new HashMap<String, Object>();
            // 分页参数
            paramMap.put("startIndex", locIndex);
            paramMap.put("maxCount", locSize);
            if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_DONE)) {
                // 审核中的数据
                paramMap.put("status", ModelConstant.PROBLEM_OPR_STATUS_DONE);
                paramMap.put("auditStaff", staffId);
            } else if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_ING)) {
                // 处理中中的数据
                paramMap.put("status", ModelConstant.PROBLEM_OPR_STATUS_ING);
                paramMap.put("checkStaff", staffId);
            } else {
                // 传入条件不符合，不进行查询
                queryFlag = false;
            }
            if (queryFlag) {
                result = dalClient.queryForList("MODEL_PROBLEM_LIST.SELECT_PROB_LIST", paramMap, ModelProbVo.class);
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 查询样机异常未处理列表
     *
     * @param staffId
     * @param index
     * @param size
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public List<ModelProbVo> queryModelProbNoHandleList(String staffId, Integer index, Integer size) {
        return this.queryModelProbVoList(staffId, ModelConstant.PROBLEM_OPR_STATUS_ING, index, size);
    }

    /**
     * 功能描述: <br>
     * 查询样机异常未审核列表
     *
     * @param staffId
     * @param index
     * @param size
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public List<ModelProbVo> queryModelProbNoAuditList(String staffId, Integer index, Integer size) {
        return this.queryModelProbVoList(staffId, ModelConstant.PROBLEM_OPR_STATUS_DONE, index, size);
    }

    /**
     * 功能描述: <br>
     * 更新样机异常数据-处理/审核
     *
     * @param commCode
     * @param reasonCode
     * @param commNum
     * @param actualCommCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    @SuppressWarnings("unchecked")
    public boolean updateModelProbOpr(String storeCode, String staffId, Integer status,
            List<ModelProbOprReqBean> probOprReqList) {
        boolean result = true;
        if (null != status && CollectionUtils.isNotEmpty(probOprReqList)) {
            boolean updateFlag = true;
            Map<String, Object>[] batchValues = new HashMap[probOprReqList.size()];
            // 更新前的状态必须如下
            Integer conditon_status = null;
            String staffKey = null;
            if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_OVER)) {
                // 审核结束前状态需要为处理完审核中
                conditon_status = ModelConstant.PROBLEM_OPR_STATUS_DONE;
                // 需指定审核人
                staffKey = "conditon_auditStaff";
            } else if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_DONE)) {
                conditon_status = ModelConstant.PROBLEM_OPR_STATUS_ING;
                // 需指定处理人
                staffKey = "conditon_checkStaff";
            } else if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_ING)) {
                // 审核驳回
                conditon_status = ModelConstant.PROBLEM_OPR_STATUS_DONE;
                // 需指定审核人
                staffKey = "conditon_auditStaff";
            } else {
                // 操作状态不对，不做任何操作
                updateFlag = false;
            }
            if (updateFlag) {
                for (int i = 0; i < probOprReqList.size(); i++) {
                    ModelProbOprReqBean probOprReq = probOprReqList.get(i);
                    Map<String, Object> map = BeanUtil.describe(probOprReq);
                    // 驳回只修改状态
                    if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_ING)) {
                        map.remove("commNum");
                        map.remove("actualCommCode");
                        map.remove("reasonCode");
                        // 更新审核时间
                        map.put("auditTime", new Date());
                    } else if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_DONE)) {
                        // 更新处理人
                        map.put("dealStaff", staffId);
                        // 更新处理时间
                        map.put("dealTime", new Date());
                    } else if (status.equals(ModelConstant.PROBLEM_OPR_STATUS_OVER)) {
                        // 更新审核时间
                        map.put("auditTime", new Date());
                    }
                    // 更新处理数量-根据不同处理原因来设置处理数量
                    if (!status.equals(ModelConstant.PROBLEM_OPR_STATUS_ING)) {
                        map.put("commNum",
                                this.getProbFinalCommNum(probOprReq.getCommNum(), probOprReq.getReasonCode()));
                    }
                    map.put("status", status);
                    // 更新要满足的条件如下 map.put("conditon_storeCode", storeCode);
                    map.put(staffKey, staffId);
                    map.put("conditon_status", conditon_status);
                    batchValues[i] = map;
                }
                // 更新，并且判断结果 - 可对数组遍历查询更新情况
                dalClient.batchUpdate("MODEL_PROBLEM_LIST.UPDATE_PROB_OPR", batchValues);
            }
        }
        return result;
    }

    /**
     * 功能描述: <br>
     * 获取异常处理-样机处理数量<br>
     * 样机清单
     */
    public Integer getProbFinalCommNum(Integer dealCommNum, String reasonCode) {
        Integer result = null;
        if (ModelConstant.PROB_REASON_LABLE.equals(reasonCode)) {
            // 异常原因为价签出样，则处理结果为0
            result = ModelConstant.NUM_ZERO;
        } else if (ModelConstant.PROB_REASON_NO_CHECK.equals(reasonCode)) {
            if (null == dealCommNum) {
                dealCommNum = ModelConstant.NUM_ZERO;
            }
            result = dealCommNum;
        }
        // 其他处理/审核原因，都不影响处理数量
        return result;
    }

    /**
     * 功能描述: <br>
     * 获取指定样机异常
     *
     * @param storeCode
     * @param commCode
     * @return
     * @see [相关类/方法](可选)
     * @since [产品/模块版本](可选)
     */
    public ModelProbVo getModelProbVo(String storeCode, String commCode) {
        ModelProbVo result = new ModelProbVo();
        Map<String, Object> paramMap = new HashMap<String, Object>();
        paramMap.put("storeCode", storeCode);
        paramMap.put("commCode", commCode);
        result = dalClient.queryForObject("MODEL_PROBLEM_LIST.SELECT_PROB", paramMap, ModelProbVo.class);
        return result;
    }

}
